home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / timer / ds3100.md / timerMC.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-12-19  |  15.3 KB  |  574 lines
  1. /*
  2.  * timerMC.c --
  3.  *
  4.  *    This file contains routines that manipulate the MC 146818 real-time
  5.  *    clock.
  6.  *
  7.  *    For a detailed explanation of the chip, see the "PMAX Desktop
  8.  *    Workstation Functional Specification, Revision 1.1" pages 62-66.
  9.  *
  10.  * Copyright (C) 1989 Digital Equipment Corporation.
  11.  * Permission to use, copy, modify, and distribute this software and
  12.  * its documentation for any purpose and without fee is hereby granted,
  13.  * provided that the above copyright notice appears in all copies.  
  14.  * Digital Equipment Corporation makes no representations about the
  15.  * suitability of this software for any purpose.  It is provided "as is"
  16.  * without express or implied warranty.
  17.  */
  18.  
  19. /*
  20.  * This chip has a real-time clock (RTC) and an interval timer.  The real-time
  21.  * clock is basically useless because it only has a resolution of seconds.
  22.  * The machine-independent part assumes that we have a free-running counter
  23.  * which has a resolution of milliseconds.  What we end up doing is
  24.  * faking the free running counter. The RTC generates an interrupt every
  25.  * second which we use to increment the seconds counter and clear the
  26.  * microseconds counter.  The interval timer is used to increment the
  27.  * microseconds counter.  We have a problem when interrupts are turned off
  28.  * since the counter doesn't get incremented.  This is fixed by comparing
  29.  * the difference in the hardware clock since the last interrupt against
  30.  * the difference in the software clock.  The hardware clock is supposed
  31.  * to go invalid 244 microseconds after the interrupt.  It isn't clear
  32.  * when the update-in-progress flag is set. My reading of the
  33.  * manual leads me to believe that it is set at the same time as the
  34.  * interrupt.  In this were true we could never read the hardware clock
  35.  * in the interrupt handler.  Either this isn't true, or we are usually
  36.  * delayed enough getting to the handler so that the clock is valid 
  37.  * again because the update-in-progress bit is never set (I ran a few
  38.  * tests).  
  39.  */
  40.  
  41. #ifndef lint
  42. static char rcsid[] = "$Header: /cdrom/src/kernel/Cvsroot/kernel/timer/ds3100.md/timerMC.c,v 9.5 90/10/19 15:58:06 rab Exp $ SPRITE (Berkeley)";
  43. #endif
  44.  
  45. #include <sprite.h>
  46. #include <sys.h>
  47. #include <timerInt.h>
  48. #include <timerTick.h>
  49. #include <spriteTime.h>
  50. #include <mach.h>
  51. #include <machMon.h>
  52. #include <prof.h>
  53. #include <timer.h>
  54. #include <machAddrs.h>
  55. #include <assert.h>
  56.  
  57. /*
  58.  * Control register A.
  59.  */
  60. #define REGA_UIP        0x80
  61. #define REGA_TIME_DIV        0x70
  62. #define REGA_RATE_SELECT    0x0F
  63.  
  64. /*
  65.  * Time base to use in the REGA_TIME_DIV field.
  66.  */
  67. #define REGA_TIME_BASE        0x20
  68.  
  69. /*
  70.  * Set the interval at 7.8125 ms.  RATE_US is the number of microseconds
  71.  * to add to the counter at each interrupt.  WHEN_TO_ADD_ONE says after
  72.  * how many intervals should one extra microsecond be added in.  This
  73.  * is necessary because the interval is actually 7812.5 microseconds.
  74.  */
  75. #define SELECTED_RATE        0x9
  76. #define RATE_US            7812
  77. #define WHEN_TO_ADD_ONE        0x1
  78.  
  79. /*
  80.  * Set up the interval structures. These are passed to Timer_CallBack
  81.  * and are used to compute the interval between callbacks. Since we have
  82.  * an interval of 7812.5 on the stupid ds3100 we have two structures and
  83.  * alternate passing them to Timer_CallBack.
  84.  * The interval is represented both as a Time, and as an integer. It is
  85.  * too expensive to convert between them later so set them both up here.
  86.  */
  87.  
  88.  
  89.  
  90. static Time lowTime = {0, 7812};
  91. static int lowInterval = 7812;
  92. static Time highTime = {0, 7813};
  93. static int highInterval = 7813;
  94.  
  95. /*
  96.  * Control register B.
  97.  */
  98. #define REGB_SET_TIME        0x80
  99. #define REGB_PER_INT_ENA    0x40
  100. #define REGB_UPDATE_INT_ENA    0x10
  101. #define REGB_DATA_MODE        0x04
  102. #define REGB_HOURS_FORMAT    0x02
  103.  
  104. /*
  105.  * Control register C.
  106.  */
  107. #define REGC_INT_PENDING    0x80
  108. #define REGC_PER_INT_PENDING    0x40
  109. #define REGC_UPDATE_INT_PENDING    0x10
  110.  
  111. /*
  112.  * Control register D.
  113.  */
  114.  
  115. #define REGD_VALID_TIME        0x80
  116. /*
  117.  * Pointers to registers. 
  118.  */
  119. volatile unsigned char    *secPtr  = (unsigned char *)(MACH_CLOCK_ADDR + 0x00);
  120. volatile unsigned char    *minPtr  = (unsigned char *)(MACH_CLOCK_ADDR + 0x08);
  121. volatile unsigned char    *hourPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x10);
  122. volatile unsigned char    *dayPtr  = (unsigned char *)(MACH_CLOCK_ADDR + 0x1C);
  123. volatile unsigned char    *monPtr  = (unsigned char *)(MACH_CLOCK_ADDR + 0x20);
  124. volatile unsigned char    *yearPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x24);
  125. volatile unsigned char    *regAPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x28);
  126. volatile unsigned char    *regBPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x2C);
  127. volatile unsigned char    *regCPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x30);
  128. volatile unsigned char    *regDPtr = (unsigned char *)(MACH_CLOCK_ADDR + 0x34);
  129.  
  130. /*
  131.  * We store a couple of things in the non-volatile ram.
  132.  */
  133.  
  134. #define NVR_ADDR (MACH_CLOCK_ADDR + 0x38)
  135.  
  136. volatile unsigned char *localOffsetNVMPtr = (unsigned char *) (NVR_ADDR + 0x00);
  137. volatile unsigned char *DSTAllowNVMPtr    = (unsigned char *) (NVR_ADDR + 0x04);
  138.  
  139. #define ONE_MILLION    1000000
  140.  
  141. /*
  142.  * The "free running counter"
  143.  */
  144. Timer_Ticks counter;
  145.  
  146. Boolean    callbackIntrsWanted = FALSE;
  147. Boolean profileIntrsWanted = FALSE;
  148.  
  149.  
  150. /*
  151.  * The RTC registers can only be accessed one byte at a time. This routine
  152.  * is used to write words into the non-volatile storage.
  153.  */
  154.  
  155. #define BYTECOPY(a,b,num) { \
  156.     int    i; \
  157.     for (i = 0; i < (num); i++) { \
  158.     ((char *) (b))[i] = ((char *) (a))[i]; \
  159.     } \
  160. }
  161.  
  162. /*
  163.  * Used for debugging. Counts number of times free-running counter was
  164.  * corrected.
  165.  */
  166. int     timerCorrectedClock;
  167.  
  168.  
  169. /*
  170.  *----------------------------------------------------------------------
  171.  *
  172.  * Timer_TimerInit --
  173.  *
  174.  *    Initialize the periodic timer.
  175.  *
  176.  *    N.B. This routine must be called before Timer_TimerStart.
  177.  *
  178.  * Results:
  179.  *    None.
  180.  *
  181.  * Side effects:
  182.  *    The timer is initialized.
  183.  *
  184.  *----------------------------------------------------------------------
  185.  */
  186. /*ARGSUSED*/
  187. void
  188. Timer_TimerInit(timer)
  189.     unsigned short     timer;
  190. {
  191.     *regAPtr = REGA_TIME_BASE | SELECTED_RATE;
  192.     *regBPtr = REGB_DATA_MODE | REGB_HOURS_FORMAT;
  193. }
  194.  
  195.  
  196. /*
  197.  *----------------------------------------------------------------------
  198.  *
  199.  * Timer_TimerStart --
  200.  *
  201.  *    Start the timer ticking.
  202.  *    ands starts the timer.
  203.  *
  204.  *    N.B. The timer must have been initialized with Timer_TimerInit
  205.  *    before this routine is called.
  206.  *
  207.  * Results:
  208.  *    None.
  209.  *
  210.  * Side effects:
  211.  *    The timer starts ticking.
  212.  *
  213.  *----------------------------------------------------------------------
  214.  */
  215. void
  216. Timer_TimerStart(timer)
  217.     register unsigned short timer;
  218. {
  219. #ifndef lint
  220.     unsigned char    dummy;
  221. #endif
  222.  
  223.     *regBPtr |= REGB_PER_INT_ENA;
  224. #ifndef lint
  225.     dummy = *regCPtr;
  226. #endif
  227.  
  228.     Mach_MonPrintf("Starting timer interrupts.\n");
  229.     if (timer == TIMER_CALLBACK_TIMER) {
  230.     callbackIntrsWanted = TRUE;
  231.     } else if (timer == TIMER_PROFILE_TIMER) {
  232.     profileIntrsWanted = TRUE;
  233.     } else {
  234.     panic("Timer_TimerStart: unknown timer %d\n", timer);
  235.     }
  236. }
  237.  
  238.  
  239. /*
  240.  *----------------------------------------------------------------------
  241.  *
  242.  * Timer_TimerInactivate --
  243.  *
  244.  *      Stops the specified timer such that it will cease counting and
  245.  *      also resests the mode register to 0.  If the timer has already
  246.  *      stopped and has set its output line high, clear the output so it
  247.  *      won't cause an interrupt (because we don't care that it has
  248.  *      expired).
  249.  *
  250.  * Results:
  251.  *    None.
  252.  *
  253.  * Side effects:
  254.  *    The timer is stopped.
  255.  *
  256.  *----------------------------------------------------------------------
  257.  */
  258. void
  259. Timer_TimerInactivate(timer)
  260.     register unsigned short timer;
  261. {
  262.     if (timer == TIMER_CALLBACK_TIMER) {
  263.     callbackIntrsWanted = FALSE;
  264.     } else if (timer == TIMER_PROFILE_TIMER) {
  265.     profileIntrsWanted = FALSE;
  266.     } else {
  267.     panic("Timer_TimerInactivate: unknown timer %d\n", timer);
  268.     }
  269.  
  270.     /*
  271.      * If neither type of timer interrupt is wanted, then disable
  272.      * timer interrupts.
  273.      */
  274.     if (!callbackIntrsWanted && !profileIntrsWanted) {
  275.     *regBPtr &= ~REGB_PER_INT_ENA;
  276.     }
  277. }
  278.  
  279.  
  280. /*
  281.  *----------------------------------------------------------------------
  282.  *
  283.  *  Timer_TimerServiceInterrupt --
  284.  *
  285.  *      This routine is called at every timer interrupt. 
  286.  *      It calls the timer callback queue handling if the callback timer 
  287.  *    expired and calls the profiling interrupt handling if the 
  288.  *    profile callback timer expired.
  289.  *
  290.  *  Results:
  291.  *    None.
  292.  *
  293.  *  Side Effects:
  294.  *    Routines on the timer queue may cause side effects. Profile
  295.  *    collect may take place. 
  296.  *    
  297.  *
  298.  *----------------------------------------------------------------------
  299.  */
  300. void
  301. Timer_TimerServiceInterrupt(statusReg, causeReg, pc)
  302.     unsigned int    statusReg;
  303.     unsigned int    causeReg;
  304.     Address         pc;
  305. { 
  306.     static unsigned    addOne = 0;
  307.     unsigned char     timerStatus;
  308.     Time        *timePtr;
  309.     unsigned int     interval;
  310.     Time_Parts        currentTODParts;
  311.     static int        previousSoftSeconds;
  312.     static int        previousHardSeconds;
  313.     int            softSeconds;
  314.     int            hardSeconds;
  315.     int            diff;
  316.     static Boolean    initialized = FALSE;
  317.  
  318.     static    int    eventDebug[1000];
  319.     static    int    dbgCtr = 0;
  320. #define INC(a) { (a) = ((a) + 1) % 1000; }
  321.  
  322.     timerStatus = *regCPtr;
  323.     eventDebug[dbgCtr] = 0;
  324.     if (timerStatus & REGC_PER_INT_PENDING) {
  325.     /*
  326.      * Increment the counter.
  327.      */
  328.     counter.microseconds += RATE_US;
  329.     if ((addOne & WHEN_TO_ADD_ONE) == WHEN_TO_ADD_ONE) {
  330.         counter.microseconds++;
  331.         timePtr = &highTime;
  332.         interval = highInterval;
  333.     } else {
  334.         timePtr = &lowTime;
  335.         interval = lowInterval;
  336.     }
  337.     addOne++;
  338.     if (counter.microseconds >= ONE_MILLION) {
  339.         /*
  340.          * We wrapped around. 
  341.          */
  342.         counter.microseconds = ONE_MILLION - 1;
  343.     }
  344.     }
  345.     if ((timerStatus & REGC_UPDATE_INT_PENDING)) {
  346.     /*
  347.      * RTC interrupt.
  348.      */
  349.     counter.seconds++;
  350.     counter.microseconds = 0;
  351.     eventDebug[dbgCtr] |= 0x1;
  352.     if ((*regAPtr & REGA_UIP) == 0) {
  353.         currentTODParts.seconds = *secPtr;
  354.         currentTODParts.minutes = *minPtr;
  355.         currentTODParts.hours = *hourPtr;
  356.         currentTODParts.dayOfMonth = *dayPtr;
  357.         currentTODParts.dayOfYear = -1;
  358.         currentTODParts.month = *monPtr-1;
  359.         currentTODParts.year = *yearPtr;
  360.         (void) Time_FromParts(¤tTODParts, FALSE, &hardSeconds);
  361.         softSeconds = counter.seconds;
  362.         diff = hardSeconds - previousHardSeconds;
  363.         eventDebug[dbgCtr] |= 0x4;
  364.         if (softSeconds - previousSoftSeconds != diff && initialized) {
  365.         /*
  366.          * Note that the software counter cannot be ahead of
  367.          * the hardware counter. We are only looking at the
  368.          * seconds, and the seconds are only incremented 
  369.          * during an interrupt. We only get one interrupt
  370.          * a second so we may be behind but not ahead.
  371.          */
  372.         if (softSeconds - previousSoftSeconds > diff) {
  373.             panic("Software time is ahead of hardware!\n");
  374.         }
  375.         counter.seconds = previousSoftSeconds + diff;
  376.         softSeconds = counter.seconds;
  377.         timerCorrectedClock++;
  378.         eventDebug[dbgCtr] |= 0x8;
  379.         }
  380.         previousHardSeconds = hardSeconds;
  381.         previousSoftSeconds = softSeconds;
  382.         initialized = TRUE;
  383.     }
  384.     }    
  385.     if (timerStatus & REGC_PER_INT_PENDING) {
  386.     if (mach_KernelMode) {
  387.         assert((statusReg & MACH_SR_KU_PREV) == 0);
  388.         /*
  389.          * Check for kernel profiling.  We'll sample the PC here.
  390.          */
  391.         if (profileIntrsWanted) {
  392.         TIMER_PROFILE_ROUTINE(pc);
  393.         } 
  394.     } else {
  395.         assert((statusReg & MACH_SR_KU_PREV) != 0);
  396.         Proc_GetCurrentProc()->Prof_PC = (int) pc;
  397.     }
  398.     TIMER_CALLBACK_ROUTINE(interval, *timePtr);
  399.     }
  400.     INC(dbgCtr);
  401. }
  402.  
  403.  
  404. /*
  405.  *----------------------------------------------------------------------
  406.  *
  407.  * Timer_CounterInit --
  408.  *
  409.  *    Initialize free-running counter.
  410.  *
  411.  * Results:
  412.  *    None.
  413.  *
  414.  * Side effects:
  415.  *    The specified counters begin to count.
  416.  *
  417.  *----------------------------------------------------------------------
  418.  */
  419. void
  420. Timer_CounterInit()
  421. {
  422.     counter.seconds = 0;
  423.     counter.microseconds = 0;
  424. }
  425.  
  426.  
  427. /*
  428.  *----------------------------------------------------------------------
  429.  *
  430.  *  Timer_GetCurrentTicks --
  431.  *
  432.  *      Return microseconds since boot.
  433.  *
  434.  *  Results:
  435.  *    The system up-time in ticks.
  436.  *
  437.  *  Side effects:
  438.  *    None.
  439.  *
  440.  *----------------------------------------------------------------------
  441.  */
  442. void
  443. Timer_GetCurrentTicks(ticksPtr)
  444.     Timer_Ticks    *ticksPtr;    /* Buffer to place current time. */
  445. {
  446.     DISABLE_INTR();
  447.  
  448.     *ticksPtr = counter;
  449.  
  450.     ENABLE_INTR();
  451. }
  452.  
  453.  
  454. /*
  455.  *----------------------------------------------------------------------
  456.  *
  457.  *  Timer_GetInfo --
  458.  *
  459.  *      Dummy routine to dump timer state.
  460.  *
  461.  *  Results:
  462.  *    None.
  463.  *
  464.  *  Side effects:
  465.  *    None.
  466.  *
  467.  *----------------------------------------------------------------------
  468.  */
  469. void
  470. Timer_TimerGetInfo()
  471. {
  472. }
  473.  
  474. /*
  475.  *----------------------------------------------------------------------
  476.  *
  477.  * TimerHardwareUniversalTimeInit --
  478.  *
  479.  *    Checks the battery backed up clock. If the contents are still
  480.  *    valid then we return them. 
  481.  *
  482.  *    IMPORTANT:  right now it looks like the ds3100 RTC is reset
  483.  *    by the prom during the boot.
  484.  *
  485.  * Results:
  486.  *    None.
  487.  *
  488.  * Side effects:
  489.  *    None.
  490.  *
  491.  *----------------------------------------------------------------------
  492.  */
  493.  
  494. void
  495. TimerHardwareUniversalTimeInit(timePtr, localOffsetPtr, DSTPtr)
  496.     Time *timePtr;        /* Buffer to hold universal time. */
  497.     int  *localOffsetPtr;    /* Buffer to hold local offset. */
  498.     Boolean *DSTPtr;        /* Buffer to hold DST allowed flag. */
  499. {
  500.     Time_Parts        timeParts;
  501.     int            seconds;
  502.     ReturnStatus    status;
  503.  
  504.     while ((*regAPtr & REGA_UIP) == 1) {
  505.     }
  506.     timeParts.seconds = *secPtr;
  507.     timeParts.minutes = *minPtr;
  508.     timeParts.hours = *hourPtr;
  509.     timeParts.dayOfMonth = *dayPtr;
  510.     timeParts.dayOfYear = -1;
  511.     timeParts.month = *monPtr-1;
  512.     timeParts.year = *yearPtr;
  513.     status = Time_FromParts(&timeParts, FALSE, &seconds);
  514.     if (status != SUCCESS) {
  515.     Mach_MonPrintf("Time stored in RTC is bogus.\n");
  516.     return;
  517.     }
  518.     if (*regDPtr & REGD_VALID_TIME == 0) {
  519.     Mach_MonPrintf(
  520.         "Warning: battery backed up TOD clock is invalid.\n");
  521.     return;
  522.     }
  523.     bzero((Address) timePtr, sizeof(Time));
  524.     timePtr->seconds = seconds;
  525.     BYTECOPY(localOffsetNVMPtr, localOffsetPtr, 4);
  526.     BYTECOPY(DSTAllowNVMPtr, DSTPtr, 4);
  527. }
  528.  
  529. /*
  530.  *----------------------------------------------------------------------
  531.  *
  532.  * TimerSetHardwareUniversalTime --
  533.  *
  534.  *    Sets the hardware RTC clock. Has to be called with interrupts
  535.  *    off.
  536.  *
  537.  *    IMPORTANT: The RTC is used to keep the free-running counter
  538.  *    up-to-date if we miss a few interrupts. DO NOT RESET THE RTC
  539.  *    WHILE THE KERNEL IS RUNNING!!! If you do system time will
  540.  *    not be linear and bad things will happen. Only call this routine
  541.  *    during startup and shutdown. As things now stand there is no
  542.  *    reason to call this routine at all since the RTC does not
  543.  *    appear to persist across reboots.
  544.  *
  545.  * Results:
  546.  *    None.
  547.  *
  548.  * Side effects:
  549.  *    The hardware RTC is set.
  550.  *
  551.  *----------------------------------------------------------------------
  552.  */
  553.  
  554. void
  555. TimerSetHardwareUniversalTime(timePtr, localOffset, DST)
  556.     Time *timePtr;        /* universal time. */
  557.     int  localOffset;        /* local offset. */
  558.     Boolean DST;        /* DST allowed flag. */
  559. {
  560.     Time_Parts        timeParts;
  561.  
  562.     Time_ToParts(timePtr->seconds, FALSE, &timeParts);
  563.     *regBPtr |= REGB_SET_TIME;
  564.     *secPtr = (unsigned char) timeParts.seconds;
  565.     *minPtr = (unsigned char) timeParts.minutes;
  566.     *hourPtr = (unsigned char) timeParts.hours;
  567.     *dayPtr = (unsigned char) timeParts.dayOfMonth;
  568.     *monPtr = (unsigned char) timeParts.month+1;
  569.     *yearPtr = (unsigned char) timeParts.year;
  570.     BYTECOPY(&localOffset,localOffsetNVMPtr,  4);
  571.     BYTECOPY(&DST, DSTAllowNVMPtr, 4);
  572.     *regBPtr &= ~REGB_SET_TIME;
  573. }
  574.